const express = require('express');
const router = express.Router();
const { exec } = require('child_process');
const util = require('util');
const { verifyAdmin } = require('../middleware/auth');
const mongoose = require('mongoose');

const execPromise = util.promisify(exec);

/**
 * @route   GET /api/database/status
 * @desc    获取数据库服务状态
 * @access  私有
 */
router.get('/status', async (req, res) => {
  try {
    const result = {
      mysql: { installed: false, running: false, version: '' },
      mongodb: { installed: false, running: false, version: '' }
    };

    // 检查MySQL状态
    try {
      await execPromise('which mysql');
      result.mysql.installed = true;
      
      try {
        const { stdout } = await execPromise('systemctl is-active mysql || systemctl is-active mariadb');
        result.mysql.running = stdout.trim() === 'active';
      } catch (error) {
        // 服务可能不存在或未运行
      }
      
      if (result.mysql.running) {
        try {
          const { stdout } = await execPromise('mysql --version');
          const versionMatch = stdout.match(/\d+\.\d+\.\d+/);
          result.mysql.version = versionMatch ? versionMatch[0] : '未知';
        } catch (error) {
          // 无法获取版本信息
        }
      }
    } catch (error) {
      // MySQL未安装
    }
    
    // 检查MongoDB状态
    try {
      await execPromise('which mongod');
      result.mongodb.installed = true;
      
      try {
        const { stdout } = await execPromise('systemctl is-active mongod');
        result.mongodb.running = stdout.trim() === 'active';
      } catch (error) {
        // 服务可能不存在或未运行
      }
      
      if (result.mongodb.running) {
        try {
          const { stdout } = await execPromise('mongod --version');
          const versionMatch = stdout.match(/db version v(\d+\.\d+\.\d+)/);
          result.mongodb.version = versionMatch ? versionMatch[1] : '未知';
        } catch (error) {
          // 无法获取版本信息
        }
      }
    } catch (error) {
      // MongoDB未安装
    }
    
    res.json(result);
  } catch (error) {
    res.status(500).json({ error: `获取数据库状态失败: ${error.message}` });
  }
});

/**
 * @route   POST /api/database/service/action
 * @desc    操作数据库服务（启动/停止/重启）
 * @access  私有 (仅管理员)
 */
router.post('/service/action', verifyAdmin, async (req, res) => {
  try {
    const { service, action } = req.body;
    
    if (!service || !action) {
      return res.status(400).json({ error: '未提供服务名称或操作类型' });
    }
    
    // 验证服务名称
    if (!['mysql', 'mariadb', 'mongodb'].includes(service)) {
      return res.status(400).json({ error: '不支持的数据库服务' });
    }
    
    // 验证操作类型
    if (!['start', 'stop', 'restart'].includes(action)) {
      return res.status(400).json({ error: '无效的操作类型' });
    }
    
    // 根据服务选择正确的服务名称
    let serviceName = service;
    if (service === 'mysql' || service === 'mariadb') {
      try {
        await execPromise('which mysql');
        // 检查是MySQL还是MariaDB
        const { stdout } = await execPromise('mysql --version');
        serviceName = stdout.includes('MariaDB') ? 'mariadb' : 'mysql';
      } catch (error) {
        return res.status(400).json({ error: 'MySQL/MariaDB未安装' });
      }
    } else if (service === 'mongodb') {
      serviceName = 'mongod';
    }
    
    // 执行服务操作
    await execPromise(`systemctl ${action} ${serviceName}`);
    
    res.json({
      message: `${service} ${action === 'start' ? '已启动' : action === 'stop' ? '已停止' : '已重启'}`
    });
  } catch (error) {
    res.status(500).json({ error: `操作失败: ${error.message}` });
  }
});

/**
 * @route   GET /api/database/mysql/databases
 * @desc    获取MySQL数据库列表
 * @access  私有 (仅管理员)
 */
router.get('/mysql/databases', verifyAdmin, async (req, res) => {
  try {
    // 检查MySQL是否已安装
    try {
      await execPromise('which mysql');
    } catch (error) {
      return res.status(400).json({ error: 'MySQL未安装' });
    }
    
    // 获取数据库列表（不使用密码，依赖系统用户认证）
    const { stdout } = await execPromise("mysql -e 'SHOW DATABASES;' -s");
    
    // 解析输出
    const databases = stdout.split('\n')
      .filter(line => line.trim() && !['information_schema', 'performance_schema', 'mysql', 'sys'].includes(line.trim()))
      .map(line => line.trim());
    
    res.json(databases);
  } catch (error) {
    res.status(500).json({ error: `获取MySQL数据库列表失败: ${error.message}` });
  }
});

/**
 * @route   POST /api/database/mysql/database
 * @desc    创建MySQL数据库
 * @access  私有 (仅管理员)
 */
router.post('/mysql/database', verifyAdmin, async (req, res) => {
  try {
    const { name, charset = 'utf8mb4', collation = 'utf8mb4_unicode_ci' } = req.body;
    
    if (!name) {
      return res.status(400).json({ error: '未提供数据库名称' });
    }
    
    // 验证数据库名称（防止SQL注入）
    if (!/^[a-zA-Z0-9_]+$/.test(name)) {
      return res.status(400).json({ error: '无效的数据库名称' });
    }
    
    // 检查MySQL是否已安装
    try {
      await execPromise('which mysql');
    } catch (error) {
      return res.status(400).json({ error: 'MySQL未安装' });
    }
    
    // 创建数据库
    await execPromise(`mysql -e "CREATE DATABASE \`${name}\` CHARACTER SET ${charset} COLLATE ${collation};"`);
    
    res.json({ message: `数据库 ${name} 创建成功` });
  } catch (error) {
    res.status(500).json({ error: `创建MySQL数据库失败: ${error.message}` });
  }
});

/**
 * @route   DELETE /api/database/mysql/database/:name
 * @desc    删除MySQL数据库
 * @access  私有 (仅管理员)
 */
router.delete('/mysql/database/:name', verifyAdmin, async (req, res) => {
  try {
    const { name } = req.params;
    
    // 验证数据库名称（防止SQL注入）
    if (!/^[a-zA-Z0-9_]+$/.test(name)) {
      return res.status(400).json({ error: '无效的数据库名称' });
    }
    
    // 保护系统数据库
    if (['information_schema', 'performance_schema', 'mysql', 'sys'].includes(name)) {
      return res.status(403).json({ error: '无法删除系统数据库' });
    }
    
    // 检查MySQL是否已安装
    try {
      await execPromise('which mysql');
    } catch (error) {
      return res.status(400).json({ error: 'MySQL未安装' });
    }
    
    // 删除数据库
    await execPromise(`mysql -e "DROP DATABASE \`${name}\`;"`);
    
    res.json({ message: `数据库 ${name} 已删除` });
  } catch (error) {
    res.status(500).json({ error: `删除MySQL数据库失败: ${error.message}` });
  }
});

/**
 * @route   GET /api/database/mysql/users
 * @desc    获取MySQL用户列表
 * @access  私有 (仅管理员)
 */
router.get('/mysql/users', verifyAdmin, async (req, res) => {
  try {
    // 检查MySQL是否已安装
    try {
      await execPromise('which mysql');
    } catch (error) {
      return res.status(400).json({ error: 'MySQL未安装' });
    }
    
    // 获取用户列表
    const { stdout } = await execPromise("mysql -e 'SELECT User, Host FROM mysql.user;' -s");
    
    // 解析输出
    const users = stdout.split('\n')
      .filter(line => line.trim())
      .map(line => {
        const [user, host] = line.trim().split(/\s+/);
        return { user, host };
      });
    
    res.json(users);
  } catch (error) {
    res.status(500).json({ error: `获取MySQL用户列表失败: ${error.message}` });
  }
});

/**
 * @route   POST /api/database/mysql/user
 * @desc    创建MySQL用户并授权
 * @access  私有 (仅管理员)
 */
router.post('/mysql/user', verifyAdmin, async (req, res) => {
  try {
    const { username, password, database, host = 'localhost' } = req.body;
    
    if (!username || !password) {
      return res.status(400).json({ error: '未提供用户名或密码' });
    }
    
    // 验证用户名（防止SQL注入）
    if (!/^[a-zA-Z0-9_]+$/.test(username)) {
      return res.status(400).json({ error: '无效的用户名' });
    }
    
    // 检查MySQL是否已安装
    try {
      await execPromise('which mysql');
    } catch (error) {
      return res.status(400).json({ error: 'MySQL未安装' });
    }
    
    // 创建用户
    await execPromise(`mysql -e "CREATE USER '${username}'@'${host}' IDENTIFIED BY '${password}';"`);
    
    // 如果指定了数据库，授予权限
    if (database) {
      // 验证数据库名称（防止SQL注入）
      if (!/^[a-zA-Z0-9_]+$/.test(database)) {
        return res.status(400).json({ error: '无效的数据库名称' });
      }
      
      await execPromise(`mysql -e "GRANT ALL PRIVILEGES ON \`${database}\`.* TO '${username}'@'${host}';"`);
    }
    
    // 刷新权限
    await execPromise(`mysql -e "FLUSH PRIVILEGES;"`);
    
    res.json({ message: `用户 ${username}@${host} 创建成功${database ? ` 并授权到数据库 ${database}` : ''}` });
  } catch (error) {
    res.status(500).json({ error: `创建MySQL用户失败: ${error.message}` });
  }
});

/**
 * @route   DELETE /api/database/mysql/user
 * @desc    删除MySQL用户
 * @access  私有 (仅管理员)
 */
router.delete('/mysql/user', verifyAdmin, async (req, res) => {
  try {
    const { username, host = 'localhost' } = req.body;
    
    if (!username) {
      return res.status(400).json({ error: '未提供用户名' });
    }
    
    // 验证用户名（防止SQL注入）
    if (!/^[a-zA-Z0-9_]+$/.test(username)) {
      return res.status(400).json({ error: '无效的用户名' });
    }
    
    // 检查MySQL是否已安装
    try {
      await execPromise('which mysql');
    } catch (error) {
      return res.status(400).json({ error: 'MySQL未安装' });
    }
    
    // 删除用户
    await execPromise(`mysql -e "DROP USER '${username}'@'${host}';"`);
    
    res.json({ message: `用户 ${username}@${host} 已删除` });
  } catch (error) {
    res.status(500).json({ error: `删除MySQL用户失败: ${error.message}` });
  }
});

/**
 * @route   GET /api/database/mongodb/databases
 * @desc    获取MongoDB数据库列表
 * @access  私有 (仅管理员)
 */
router.get('/mongodb/databases', verifyAdmin, async (req, res) => {
  try {
    // 使用mongoose连接到MongoDB
    if (!mongoose.connection.readyState) {
      // 如果还未连接，尝试连接
      await mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/admin');
    }
    
    // 获取所有数据库
    const admin = mongoose.connection.db.admin();
    const { databases } = await admin.listDatabases();
    
    // 过滤系统数据库
    const userDatabases = databases
      .filter(db => !['admin', 'config', 'local'].includes(db.name))
      .map(db => ({
        name: db.name,
        sizeOnDisk: db.sizeOnDisk,
        empty: db.empty
      }));
    
    res.json(userDatabases);
  } catch (error) {
    res.status(500).json({ error: `获取MongoDB数据库列表失败: ${error.message}` });
  }
});

/**
 * @route   POST /api/database/mongodb/database
 * @desc    创建MongoDB数据库和用户
 * @access  私有 (仅管理员)
 */
router.post('/mongodb/database', verifyAdmin, async (req, res) => {
  try {
    const { name, username, password } = req.body;
    
    if (!name) {
      return res.status(400).json({ error: '未提供数据库名称' });
    }
    
    // 验证数据库名称
    if (!/^[a-zA-Z0-9_]+$/.test(name)) {
      return res.status(400).json({ error: '无效的数据库名称' });
    }
    
    // 使用mongoose连接到MongoDB
    if (!mongoose.connection.readyState) {
      // 如果还未连接，尝试连接
      await mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/admin');
    }
    
    // 创建一个集合来初始化数据库
    await mongoose.connection.db.admin().command({ create: name });
    
    // 如果提供了用户名和密码，创建用户
    if (username && password) {
      await mongoose.connection.db.admin().command({
        createUser: username,
        pwd: password,
        roles: [{ role: 'readWrite', db: name }]
      });
      
      res.json({ message: `数据库 ${name} 和用户 ${username} 创建成功` });
    } else {
      res.json({ message: `数据库 ${name} 创建成功` });
    }
  } catch (error) {
    res.status(500).json({ error: `创建MongoDB数据库失败: ${error.message}` });
  }
});

/**
 * @route   DELETE /api/database/mongodb/database/:name
 * @desc    删除MongoDB数据库
 * @access  私有 (仅管理员)
 */
router.delete('/mongodb/database/:name', verifyAdmin, async (req, res) => {
  try {
    const { name } = req.params;
    
    // 验证数据库名称
    if (!/^[a-zA-Z0-9_]+$/.test(name)) {
      return res.status(400).json({ error: '无效的数据库名称' });
    }
    
    // 保护系统数据库
    if (['admin', 'config', 'local'].includes(name)) {
      return res.status(403).json({ error: '无法删除系统数据库' });
    }
    
    // 使用mongoose连接到MongoDB
    if (!mongoose.connection.readyState) {
      // 如果还未连接，尝试连接
      await mongoose.connect(process.env.MONGODB_URI || 'mongodb://localhost:27017/admin');
    }
    
    // 删除数据库
    await mongoose.connection.db.admin().command({ dropDatabase: 1, dbName: name });
    
    res.json({ message: `数据库 ${name} 已删除` });
  } catch (error) {
    res.status(500).json({ error: `删除MongoDB数据库失败: ${error.message}` });
  }
});

module.exports = router; 